home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / gepackte_disketten / 1994 / 08_94_5.dms / 08_94_5.adf / term-4.0-Source.lha / RatePanel.c < prev    next >
C/C++ Source or Header  |  1994-06-26  |  29KB  |  1,297 lines
  1. /*
  2. **    RatePanel.c
  3. **
  4. **    Editing panel for phone units configuration
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_TIME=1,GAD_ADDTIME,GAD_REMOVETIME,GAD_EDITTIME,
  13.         GAD_PAY1,GAD_MINUTES1,
  14.         GAD_PAY2,GAD_MINUTES2,
  15.         GAD_LIST,
  16.         GAD_ADDDATE,GAD_ADDDAY,GAD_EDIT,
  17.         GAD_CLONE,GAD_REMOVE,GAD_IMPORT
  18.     };
  19.  
  20. struct DoubleInfo
  21. {
  22.     LONG    GlyphWidth,
  23.         HeaderLen;
  24. };
  25.  
  26.     /* ListViewRender():
  27.      *
  28.      *    This callback routine is responsible for rendering
  29.      *    the single listview entries.
  30.      */
  31.  
  32. STATIC ULONG __saveds __asm
  33. ListViewRender(register __a0 struct Hook *Hook,register __a1 struct LVDrawMsg *Msg,register __a2 struct Node *Node)
  34. {
  35.         /* We only know how to redraw lines. */
  36.  
  37.     if(Msg -> lvdm_MethodID == LV_DRAW)
  38.     {
  39.         struct RastPort        *RPort    = Msg -> lvdm_RastPort;
  40.         LONG             Left    = Msg -> lvdm_Bounds . MinX,
  41.                      Top    = Msg -> lvdm_Bounds . MinY,
  42.                      Width    = Msg -> lvdm_Bounds . MaxX - Msg -> lvdm_Bounds . MinX + 1,
  43.                      Height    = Msg -> lvdm_Bounds . MaxY - Msg -> lvdm_Bounds . MinY + 1,
  44.                      Delta,
  45.                      FgPen,BgPen,
  46.                      Len,LabelLen,Template;
  47.         UBYTE            *String,Header[8];
  48.         struct DoubleInfo    *Info;
  49.  
  50.         Info = Hook -> h_Data;
  51.  
  52.         String = &Node -> ln_Name[Info -> HeaderLen];
  53.  
  54.         memcpy(Header,Node -> ln_Name,Info -> HeaderLen);
  55.  
  56.         Header[Info -> HeaderLen] = 0;
  57.  
  58.             /* Determine the rendering pens. */
  59.  
  60.         switch(Msg -> lvdm_State)
  61.         {
  62.             case LVR_SELECTEDDISABLED:
  63.             case LVR_NORMALDISABLED:
  64.             case LVR_NORMAL:
  65.  
  66.                 FgPen = Msg -> lvdm_DrawInfo -> dri_Pens[TEXTPEN];
  67.                 BgPen = Msg -> lvdm_DrawInfo -> dri_Pens[BACKGROUNDPEN];
  68.                 break;
  69.  
  70.             case LVR_SELECTED:
  71.  
  72.                 FgPen = Msg -> lvdm_DrawInfo -> dri_Pens[FILLTEXTPEN];
  73.                 BgPen = Msg -> lvdm_DrawInfo -> dri_Pens[FILLPEN];
  74.                 break;
  75.         }
  76.  
  77.         SetAPen(RPort,BgPen);
  78.         RectFill(RPort,Left,Top,Left + 1,Top + Height - 1);
  79.  
  80.         Left    += 2;
  81.         Width    -= 2;
  82.  
  83.             /* Set the rendering pens. */
  84.  
  85.         SetDrMd(RPort,JAM2);
  86.         SetBPen(RPort,BgPen);
  87.  
  88.         Template = Info -> HeaderLen * Info -> GlyphWidth;
  89.  
  90.             /* Determine header length. */
  91.  
  92.         Len = TextLength(RPort,Header,Info -> HeaderLen);
  93.  
  94.             /* Fill the space to precede the header. */
  95.  
  96.         if((Delta = Template - Len) > 0)
  97.         {
  98.             SetAPen(RPort,BgPen);
  99.             RectFill(RPort,Left,Top,Left + Delta - 1,Top + Height - 1);
  100.         }
  101.  
  102.             /* Render the header, right-justified. */
  103.  
  104.         SetAPen(RPort,FgPen);
  105.  
  106.         Move(RPort,Left + Delta,Top + RPort -> Font -> tf_Baseline);
  107.         Text(RPort,Header,Info -> HeaderLen);
  108.  
  109.             /* Adjust width and area left edge. */
  110.  
  111.         Left    += Template;
  112.         Width    -= Template;
  113.  
  114.             /* Determine length of vanilla name. */
  115.  
  116.         LabelLen = strlen(String);
  117.  
  118.             /* Try to make it fit. */
  119.  
  120.         while(LabelLen > 0 && (Len = TextLength(RPort,String,LabelLen)) > Width)
  121.             LabelLen--;
  122.  
  123.             /* Print the vanilla name if possible. */
  124.  
  125.         if(LabelLen)
  126.         {
  127.             Move(RPort,Left,Top + RPort -> Font -> tf_Baseline);
  128.             Text(RPort,String,LabelLen);
  129.  
  130.             Left    += Len;
  131.             Width    -= Len;
  132.         }
  133.  
  134.             /* Fill the area to follow the vanilla name. */
  135.  
  136.         if(Width > 0)
  137.         {
  138.             SetAPen(RPort,BgPen);
  139.             RectFill(RPort,Left,Top,Left + Width - 1,Top + Height - 1);
  140.         }
  141.  
  142.             /* If the item happens to be disabled, draw the cross-hatch
  143.              * pattern across it.
  144.              */
  145.  
  146.         if(Msg -> lvdm_State == LVR_SELECTEDDISABLED || Msg -> lvdm_State == LVR_NORMALDISABLED)
  147.         {
  148.             SetDrMd(RPort,JAM1);
  149.  
  150.             SetAPen(RPort,Msg -> lvdm_DrawInfo -> dri_Pens[BLOCKPEN]);
  151.  
  152.             SetAfPt(RPort,(UWORD *)&Ghosting,1);
  153.  
  154.             RectFill(RPort,Msg -> lvdm_Bounds . MinX,Msg -> lvdm_Bounds . MinY,Msg -> lvdm_Bounds . MaxX,Msg -> lvdm_Bounds . MaxY);
  155.  
  156.             SetAfPt(RPort,NULL,0);
  157.         }
  158.  
  159.         return(LVCB_OK);
  160.     }
  161.     else
  162.         return(LVCB_UNKNOWN);
  163. }
  164.  
  165. STATIC VOID __regargs
  166. DisableGadgets(struct LayoutHandle *Handle,BOOLEAN Mode,BOOLEAN SetEntries,BOOLEAN SetTime)
  167. {
  168.     LT_SetAttributes(Handle,GAD_TIME,
  169.         GA_Disabled,    Mode,
  170.     TAG_DONE);
  171.  
  172.     LT_SetAttributes(Handle,GAD_PAY1,
  173.         GA_Disabled,    Mode,
  174.     TAG_DONE);
  175.  
  176.     LT_SetAttributes(Handle,GAD_MINUTES1,
  177.         GA_Disabled,    Mode,
  178.     TAG_DONE);
  179.  
  180.     LT_SetAttributes(Handle,GAD_PAY2,
  181.         GA_Disabled,    Mode,
  182.     TAG_DONE);
  183.  
  184.     LT_SetAttributes(Handle,GAD_MINUTES2,
  185.         GA_Disabled,    Mode,
  186.     TAG_DONE);
  187.  
  188.     if(SetEntries)
  189.     {
  190.         LT_SetAttributes(Handle,GAD_EDIT,
  191.             GA_Disabled,    Mode,
  192.         TAG_DONE);
  193.  
  194.         LT_SetAttributes(Handle,GAD_CLONE,
  195.             GA_Disabled,    Mode,
  196.         TAG_DONE);
  197.  
  198.         LT_SetAttributes(Handle,GAD_REMOVE,
  199.             GA_Disabled,    Mode,
  200.         TAG_DONE);
  201.     }
  202.  
  203.     if(SetTime)
  204.     {
  205.         LT_SetAttributes(Handle,GAD_TIME,
  206.             GA_Disabled,    Mode,
  207.         TAG_DONE);
  208.  
  209.         LT_SetAttributes(Handle,GAD_ADDTIME,
  210.             GA_Disabled,    Mode,
  211.         TAG_DONE);
  212.  
  213.         LT_SetAttributes(Handle,GAD_REMOVETIME,
  214.             GA_Disabled,    Mode,
  215.         TAG_DONE);
  216.  
  217.         LT_SetAttributes(Handle,GAD_EDITTIME,
  218.             GA_Disabled,    Mode,
  219.         TAG_DONE);
  220.     }
  221. }
  222.  
  223. BYTE __regargs
  224. RatePanel(struct List *PhoneList,struct PhoneEntry *Entry)
  225. {
  226.     STATIC struct DoubleInfo TimeInfo;
  227.  
  228.     STATIC struct Hook TimeHook =
  229.     {
  230.         {NULL},
  231.         (HOOKFUNC)ListViewRender,
  232.         (HOOKFUNC)NULL,
  233.         &TimeInfo
  234.     };
  235.  
  236.     STATIC struct DoubleInfo DateInfo;
  237.  
  238.     STATIC struct Hook DateHook =
  239.     {
  240.         {NULL},
  241.         (HOOKFUNC)ListViewRender,
  242.         (HOOKFUNC)NULL,
  243.         &DateInfo
  244.     };
  245.  
  246.     struct LayoutHandle    *Handle;
  247.     BYTE             MadeChanges = FALSE;
  248.  
  249.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  250.         LH_LocaleHook,    &LocaleHook,
  251.     TAG_DONE))
  252.     {
  253.         struct Window    *Window;
  254.         LONG         i,Max = 0,Size;
  255.         UBYTE         SmallString[2];
  256.  
  257.         SmallString[1] = 0;
  258.  
  259.         for(i = '0' ; i <= '9' ; i++)
  260.         {
  261.             SmallString[0] = i;
  262.  
  263.             if((Size = LT_LabelWidth(Handle,SmallString)) > Max)
  264.                 Max = Size;
  265.         }
  266.  
  267.         TimeInfo . GlyphWidth    = Max;
  268.         TimeInfo . HeaderLen    = 2;
  269.  
  270.         DateInfo . GlyphWidth    = Max;
  271.         DateInfo . HeaderLen    = 7;
  272.  
  273.         LT_New(Handle,
  274.             LA_Type,    VERTICAL_KIND,
  275.         TAG_DONE);
  276.         {
  277.             LT_New(Handle,
  278.                 LA_Type,    HORIZONTAL_KIND,
  279.             TAG_DONE);
  280.             {
  281.                 LT_New(Handle,
  282.                     LA_Type,    VERTICAL_KIND,
  283.                     LA_LabelID,    MSG_V36_0156,
  284.                 TAG_DONE);
  285.                 {
  286.                     LT_New(Handle,
  287.                         LA_Type,    LISTVIEW_KIND,
  288.                         LA_LabelID,    MSG_RATEPANEL_TIME_GAD,
  289.                         LA_Chars,    6,
  290.                         LA_Lines,    6,
  291.                         LA_ID,        GAD_TIME,
  292.                         GA_Disabled,    TRUE,
  293.                         GTLV_CallBack,    &TimeHook,
  294.                         LALV_Link,    NIL_LINK,
  295.                     TAG_DONE);
  296.  
  297.                     LT_New(Handle,
  298.                         LA_Type,    BUTTON_KIND,
  299.                         LA_LabelID,    MSG_RATEPANEL_ADD_TIME_GAD,
  300.                         LA_ID,        GAD_ADDTIME,
  301.                         GA_Disabled,    TRUE,
  302.                     TAG_DONE);
  303.  
  304.                     LT_New(Handle,
  305.                         LA_Type,    BUTTON_KIND,
  306.                         LA_LabelID,    MSG_RATEPANEL_REMOVE_TIME_GAD,
  307.                         LA_ID,        GAD_REMOVETIME,
  308.                         GA_Disabled,    TRUE,
  309.                     TAG_DONE);
  310.  
  311.                     LT_New(Handle,
  312.                         LA_Type,    BUTTON_KIND,
  313.                         LA_LabelID,    MSG_RATEPANEL_EDIT_TIME_GAD,
  314.                         LA_ID,        GAD_EDITTIME,
  315.                         GA_Disabled,    TRUE,
  316.                     TAG_DONE);
  317.  
  318.                     LT_EndGroup(Handle);
  319.                 }
  320.  
  321.                 LT_New(Handle,
  322.                     LA_Type,    HORIZONTAL_KIND,
  323.                     LA_LabelID,    MSG_V36_0157,
  324.                 TAG_DONE);
  325.                 {
  326.                     LT_New(Handle,
  327.                         LA_Type,    VERTICAL_KIND,
  328.                     TAG_DONE);
  329.                     {
  330.                         LT_New(Handle,
  331.                             LA_Type,    VERTICAL_KIND,
  332.                             LA_LabelID,    MSG_RATEPANEL_FIRST_UNIT_GAD,
  333.                         TAG_DONE);
  334.                         {
  335.                             LT_New(Handle,
  336.                                 LA_Type,        INTEGER_KIND,
  337.                                 LA_LabelText,        SmallCurrency(),
  338.                                 LA_Chars,        10,
  339.                                 LA_ID,            GAD_PAY1,
  340.                                 LAIN_UseIncrementers,    TRUE,
  341.                                 LAIN_Min,        0,
  342.                                 GA_Disabled,        TRUE,
  343.                             TAG_DONE);
  344.  
  345.                             LT_New(Handle,
  346.                                 LA_Type,        INTEGER_KIND,
  347.                                 LA_LabelID,        MSG_RATEPANEL_SECONDS_PER_UNIT_GAD,
  348.                                 LA_ID,            GAD_MINUTES1,
  349.                                 LAIN_UseIncrementers,    TRUE,
  350.                                 LAIN_Min,        0,
  351.                                 GA_Disabled,        TRUE,
  352.                             TAG_DONE);
  353.  
  354.                             LT_EndGroup(Handle);
  355.                         }
  356.  
  357.                         LT_New(Handle,
  358.                             LA_Type,    VERTICAL_KIND,
  359.                             LA_LabelID,    MSG_RATEPANEL_FOLLOWING_UNITS_GAD,
  360.                         TAG_DONE);
  361.                         {
  362.                             LT_New(Handle,
  363.                                 LA_Type,        INTEGER_KIND,
  364.                                 LA_LabelText,        SmallCurrency(),
  365.                                 LA_Chars,        10,
  366.                                 LA_ID,            GAD_PAY2,
  367.                                 LAIN_UseIncrementers,    TRUE,
  368.                                 LAIN_Min,        0,
  369.                                 GA_Disabled,        TRUE,
  370.                             TAG_DONE);
  371.  
  372.                             LT_New(Handle,
  373.                                 LA_Type,        INTEGER_KIND,
  374.                                 LA_LabelID,        MSG_RATEPANEL_SECONDS_PER_UNIT_GAD,
  375.                                 LA_ID,            GAD_MINUTES2,
  376.                                 LAIN_UseIncrementers,    TRUE,
  377.                                 LAIN_Min,        0,
  378.                                 GA_Disabled,        TRUE,
  379.                             TAG_DONE);
  380.  
  381.                             LT_EndGroup(Handle);
  382.                         }
  383.  
  384.                         LT_EndGroup(Handle);
  385.                     }
  386.  
  387.                     LT_New(Handle,
  388.                         LA_Type,    VERTICAL_KIND,
  389.                     TAG_DONE);
  390.                     {
  391.                         LT_New(Handle,
  392.                             LA_Type,    LISTVIEW_KIND,
  393.                             LA_LabelID,    MSG_RATEPANEL_DAYS_AND_DATES_GAD,
  394.                             LA_Chars,    30,
  395.                             LA_Lines,    10,
  396.                             LA_ID,        GAD_LIST,
  397.                             GTLV_CallBack,    &DateHook,
  398.                             GTLV_Labels,    &Entry -> TimeDateList,
  399.                             LALV_Link,    NIL_LINK,
  400.                         TAG_DONE);
  401.  
  402.                         LT_EndGroup(Handle);
  403.                     }
  404.  
  405.                     LT_EndGroup(Handle);
  406.                 }
  407.  
  408.                 LT_EndGroup(Handle);
  409.             }
  410.  
  411.             LT_New(Handle,
  412.                 LA_Type,    VERTICAL_KIND,
  413.             TAG_DONE);
  414.             {
  415.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  416.  
  417.                 LT_EndGroup(Handle);
  418.             }
  419.  
  420.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  421.                 LAGR_Spread,    TRUE,
  422.             TAG_DONE);
  423.             {
  424.                 LT_New(Handle,
  425.                     LA_Type,    BUTTON_KIND,
  426.                     LA_LabelID,    MSG_RATEPANEL_ADD_DATE_GAD,
  427.                     LA_ID,        GAD_ADDDATE,
  428.                     LABT_ExtraFat,    TRUE,
  429.                 TAG_DONE);
  430.  
  431.                 LT_New(Handle,
  432.                     LA_Type,    BUTTON_KIND,
  433.                     LA_LabelID,    MSG_RATEPANEL_ADD_DAYS_GAD,
  434.                     LA_ID,        GAD_ADDDAY,
  435.                     LABT_ExtraFat,    TRUE,
  436.                 TAG_DONE);
  437.  
  438.                 LT_New(Handle,
  439.                     LA_Type,    BUTTON_KIND,
  440.                     LA_LabelID,    MSG_RATEPANEL_EDIT_GAD,
  441.                     LA_ID,        GAD_EDIT,
  442.                     LABT_ExtraFat,    TRUE,
  443.                     GA_Disabled,    TRUE,
  444.                 TAG_DONE);
  445.  
  446.                 LT_New(Handle,
  447.                     LA_Type,    BUTTON_KIND,
  448.                     LA_LabelID,    MSG_RATEPANEL_CLONE_GAD,
  449.                     LA_ID,        GAD_CLONE,
  450.                     LABT_ExtraFat,    TRUE,
  451.                     GA_Disabled,    TRUE,
  452.                 TAG_DONE);
  453.  
  454.                 LT_New(Handle,
  455.                     LA_Type,    BUTTON_KIND,
  456.                     LA_LabelID,    MSG_GLOBAL_REMOVE_GAD,
  457.                     LA_ID,        GAD_REMOVE,
  458.                     LABT_ExtraFat,    TRUE,
  459.                     GA_Disabled,    TRUE,
  460.                 TAG_DONE);
  461.  
  462.                 LT_New(Handle,
  463.                     LA_Type,    BUTTON_KIND,
  464.                     LA_LabelID,    MSG_RATEPANEL_IMPORT_GAD,
  465.                     LA_ID,        GAD_IMPORT,
  466.                     LABT_ExtraFat,    TRUE,
  467.                 TAG_DONE);
  468.  
  469.                 LT_EndGroup(Handle);
  470.             }
  471.  
  472.             LT_EndGroup(Handle);
  473.         }
  474.  
  475.         if(Window = LT_Layout(Handle,LocaleString(MSG_RATEPANEL_RATES_PREFERENCES_TXT),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  476.             LAWN_HelpHook,        &GuideHook,
  477.             WA_DepthGadget,        TRUE,
  478.             WA_CloseGadget,        TRUE,
  479.             WA_DragBar,        TRUE,
  480.             WA_RMBTrap,        TRUE,
  481.             WA_Activate,        TRUE,
  482.         TAG_DONE))
  483.         {
  484.             struct IntuiMessage    *Message;
  485.             BOOLEAN             Done = FALSE;
  486.             ULONG             MsgClass,
  487.                          MsgQualifier;
  488.             UWORD             MsgCode;
  489.             struct Gadget        *MsgGadget;
  490.  
  491.             struct TimeDateNode    *TimeDateNode,
  492.                         *NewNode;
  493.             struct List        *TimeList    = NULL;
  494.             LONG             Selected    = ~0,
  495.                          Count        =  0,
  496.                          TimeSelected    = ~0;
  497.  
  498.             GuideContext(CONTEXT_RATES);
  499.  
  500.             TimeDateNode = (struct TimeDateNode *)Entry -> TimeDateList . mlh_Head;
  501.  
  502.             while(TimeDateNode -> VanillaNode . ln_Succ)
  503.             {
  504.                 Count++;
  505.  
  506.                 TimeDateNode = (struct TimeDateNode *)TimeDateNode -> VanillaNode . ln_Succ;
  507.             }
  508.  
  509.             PushWindow(Window);
  510.  
  511.             LT_ShowWindow(Handle,TRUE);
  512.  
  513.             do
  514.             {
  515.                 if(Wait(PORTMASK(Window -> UserPort) | SIG_BREAK) & SIG_BREAK)
  516.                     break;
  517.  
  518.                 while(Message = (struct IntuiMessage *)GT_GetIMsg(Window -> UserPort))
  519.                 {
  520.                     MsgClass    = Message -> Class;
  521.                     MsgQualifier    = Message -> Qualifier;
  522.                     MsgCode        = Message -> Code;
  523.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  524.  
  525.                     GT_ReplyIMsg(Message);
  526.  
  527.                     LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  528.  
  529.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  530.                         Done = TRUE;
  531.  
  532.                     if(MsgClass == IDCMP_GADGETUP)
  533.                     {
  534.                         switch(MsgGadget -> GadgetID)
  535.                         {
  536.                             case GAD_TIME:
  537.  
  538.                                 TimeSelected = MsgCode;
  539.  
  540.                                 if(Selected != ~0)
  541.                                 {
  542.                                     LT_SetAttributes(Handle,GAD_PAY1,
  543.                                         GTIN_Number,    TimeDateNode -> Table[TimeSelected] . PayPerUnit[DT_FIRST_UNIT],
  544.                                     TAG_DONE);
  545.  
  546.                                     LT_SetAttributes(Handle,GAD_MINUTES1,
  547.                                         GTIN_Number,    TimeDateNode -> Table[TimeSelected] . SecPerUnit[DT_FIRST_UNIT],
  548.                                     TAG_DONE);
  549.  
  550.                                     LT_SetAttributes(Handle,GAD_PAY2,
  551.                                         GTIN_Number,    TimeDateNode -> Table[TimeSelected] . PayPerUnit[DT_NEXT_UNIT],
  552.                                     TAG_DONE);
  553.  
  554.                                     LT_SetAttributes(Handle,GAD_MINUTES2,
  555.                                         GTIN_Number,    TimeDateNode -> Table[TimeSelected] . SecPerUnit[DT_NEXT_UNIT],
  556.                                     TAG_DONE);
  557.                                 }
  558.  
  559.                                 break;
  560.  
  561.                             case GAD_EDITTIME:
  562.  
  563.                                 if(Selected != ~0 && TimeSelected != ~0)
  564.                                 {
  565.                                     UBYTE Time = TimeDateNode -> Table[TimeSelected] . Time;
  566.  
  567.                                     LT_LockWindow(Window);
  568.  
  569.                                     if(TimePanel(&TimeDateNode -> Table[TimeSelected] . Time))
  570.                                     {
  571.                                         struct List *NewTimeList;
  572.  
  573.                                         MadeChanges = TRUE;
  574.  
  575.                                         SortTimeTable(TimeDateNode);
  576.  
  577.                                         if(NewTimeList = BuildTimeList(TimeDateNode))
  578.                                         {
  579.                                             LT_SetAttributes(Handle,GAD_TIME,
  580.                                                 GTLV_Labels,    ~0,
  581.                                             TAG_DONE);
  582.  
  583.                                             if(TimeList)
  584.                                                 FreeVecPooled(TimeList);
  585.  
  586.                                             TimeList = NewTimeList;
  587.  
  588.                                             LT_SetAttributes(Handle,GAD_TIME,
  589.                                                 GTLV_Labels,    TimeList,
  590.                                                 GTLV_Selected,    0,
  591.                                                 GA_Disabled,    FALSE,
  592.                                             TAG_DONE);
  593.  
  594.                                             LT_SetAttributes(Handle,GAD_LIST,
  595.                                                 GTLV_Labels,    ~0,
  596.                                             TAG_DONE);
  597.  
  598.                                             DisableGadgets(Handle,TRUE,TRUE,TRUE);
  599.  
  600.                                             LT_SetAttributes(Handle,GAD_LIST,
  601.                                                 GTLV_Labels,    &Entry -> TimeDateList,
  602.                                                 GTLV_Selected,    ~0,
  603.                                             TAG_DONE);
  604.  
  605.                                             Selected = ~0;
  606.  
  607.                                             TimeSelected = ~0;
  608.                                         }
  609.                                         else
  610.                                         {
  611.                                             TimeDateNode -> Table[TimeSelected] . Time = Time;
  612.  
  613.                                             SortTimeTable(TimeDateNode);
  614.  
  615.                                             DisplayBeep(Window -> WScreen);
  616.                                         }
  617.                                     }
  618.  
  619.                                     LT_UnlockWindow(Window);
  620.  
  621.                                     LT_ShowWindow(Handle,TRUE);
  622.                                 }
  623.  
  624.                                 break;
  625.  
  626.                             case GAD_REMOVETIME:
  627.  
  628.                                 if(Selected != ~0 && TimeSelected != ~0)
  629.                                 {
  630.                                     MadeChanges = TRUE;
  631.  
  632.                                     LT_LockWindow(Window);
  633.  
  634.                                     LT_SetAttributes(Handle,GAD_TIME,
  635.                                         GTLV_Labels,    ~0,
  636.                                     TAG_DONE);
  637.  
  638.                                     if(DeleteTimeDateNode(TimeDateNode,TimeSelected))
  639.                                     {
  640.                                         if(TimeList)
  641.                                             FreeVecPooled(TimeList);
  642.  
  643.                                         if(TimeList = BuildTimeList(TimeDateNode))
  644.                                         {
  645.                                             LT_SetAttributes(Handle,GAD_TIME,
  646.                                                 GTLV_Labels,    TimeList,
  647.                                                 GTLV_Selected,    0,
  648.                                                 GA_Disabled,    FALSE,
  649.                                             TAG_DONE);
  650.  
  651.                                             LT_SetAttributes(Handle,GAD_LIST,
  652.                                                 GTLV_Labels,    ~0,
  653.                                             TAG_DONE);
  654.  
  655.                                             DisableGadgets(Handle,TRUE,TRUE,TRUE);
  656.  
  657.                                             LT_SetAttributes(Handle,GAD_LIST,
  658.                                                 GTLV_Labels,    &Entry -> TimeDateList,
  659.                                                 GTLV_Selected,    ~0,
  660.                                             TAG_DONE);
  661.  
  662.                                             Selected = ~0;
  663.  
  664.                                             TimeSelected = ~0;
  665.                                         }
  666.                                         else
  667.                                         {
  668.                                             LT_SetAttributes(Handle,GAD_TIME,
  669.                                                 GTLV_Labels,    &EmptyList,
  670.                                             TAG_DONE);
  671.  
  672.                                             DisplayBeep(Window -> WScreen);
  673.                                         }
  674.                                     }
  675.                                     else
  676.                                     {
  677.                                         LT_SetAttributes(Handle,GAD_TIME,
  678.                                             GTLV_Labels,    TimeList,
  679.                                             GTLV_Selected,    TimeSelected,
  680.                                         TAG_DONE);
  681.  
  682.                                         DisplayBeep(Window -> WScreen);
  683.                                     }
  684.  
  685.                                     LT_UnlockWindow(Window);
  686.                                 }
  687.  
  688.                                 break;
  689.  
  690.                             case GAD_ADDTIME:
  691.  
  692.                                 if(Selected != ~0)
  693.                                 {
  694.                                     UBYTE Time = DT_GET_TIME(12,0);
  695.  
  696.                                     MadeChanges = TRUE;
  697.  
  698.                                     LT_LockWindow(Window);
  699.  
  700.                                     if(TimePanel(&Time))
  701.                                     {
  702.                                         BYTE AddIt = TRUE;
  703.                                         LONG i;
  704.  
  705.                                         for(i = 0 ; i < TimeDateNode -> Table[0] . Count ; i++)
  706.                                         {
  707.                                             if(Time == TimeDateNode -> Table[i] . Time)
  708.                                             {
  709.                                                 AddIt = FALSE;
  710.                                                 break;
  711.                                             }
  712.                                         }
  713.  
  714.                                         if(AddIt)
  715.                                         {
  716.                                             LT_SetAttributes(Handle,GAD_TIME,
  717.                                                 GTLV_Labels,    ~0,
  718.                                             TAG_DONE);
  719.  
  720.                                             if(ResizeTimeDateNode(TimeDateNode,TimeDateNode -> Table[0] . Count + 1,Time))
  721.                                             {
  722.                                                 SortTimeTable(TimeDateNode);
  723.  
  724.                                                 if(TimeList)
  725.                                                     FreeVecPooled(TimeList);
  726.  
  727.                                                 if(TimeList = BuildTimeList(TimeDateNode))
  728.                                                 {
  729.                                                     LT_SetAttributes(Handle,GAD_TIME,
  730.                                                         GTLV_Labels,    TimeList,
  731.                                                         GTLV_Selected,    0,
  732.                                                         GA_Disabled,    FALSE,
  733.                                                     TAG_DONE);
  734.  
  735.                                                     LT_SetAttributes(Handle,GAD_LIST,
  736.                                                         GTLV_Labels,    ~0,
  737.                                                     TAG_DONE);
  738.  
  739.                                                     DisableGadgets(Handle,TRUE,TRUE,TRUE);
  740.  
  741.                                                     LT_SetAttributes(Handle,GAD_LIST,
  742.                                                         GTLV_Labels,    &Entry -> TimeDateList,
  743.                                                         GTLV_Selected,    ~0,
  744.                                                     TAG_DONE);
  745.  
  746.                                                     Selected = ~0;
  747.  
  748.                                                     TimeSelected = ~0;
  749.                                                 }
  750.                                                 else
  751.                                                 {
  752.                                                     LT_SetAttributes(Handle,GAD_TIME,
  753.                                                         GTLV_Labels,    &EmptyList,
  754.                                                     TAG_DONE);
  755.  
  756.                                                     DisplayBeep(Window -> WScreen);
  757.                                                 }
  758.                                             }
  759.                                             else
  760.                                             {
  761.                                                 LT_SetAttributes(Handle,GAD_TIME,
  762.                                                     GTLV_Labels,    TimeList,
  763.                                                     GTLV_Selected,    TimeSelected,
  764.                                                 TAG_DONE);
  765.  
  766.                                                 DisplayBeep(Window -> WScreen);
  767.                                             }
  768.                                         }
  769.                                     }
  770.  
  771.                                     LT_UnlockWindow(Window);
  772.  
  773.                                     LT_ShowWindow(Handle,TRUE);
  774.                                 }
  775.  
  776.                                 break;
  777.  
  778.                             case GAD_PAY1:
  779.  
  780.                                 TimeDateNode -> Table[TimeSelected] . PayPerUnit[DT_FIRST_UNIT] = LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE);
  781.  
  782.                                 MadeChanges = TRUE;
  783.  
  784.                                 break;
  785.  
  786.                             case GAD_PAY2:
  787.  
  788.                                 TimeDateNode -> Table[TimeSelected] . PayPerUnit[DT_NEXT_UNIT] = LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE);
  789.  
  790.                                 MadeChanges = TRUE;
  791.  
  792.                                 break;
  793.  
  794.                             case GAD_MINUTES1:
  795.  
  796.                                 TimeDateNode -> Table[TimeSelected] . SecPerUnit[DT_FIRST_UNIT] = LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE);
  797.  
  798.                                 MadeChanges = TRUE;
  799.  
  800.                                 break;
  801.  
  802.                             case GAD_MINUTES2:
  803.  
  804.                                 TimeDateNode -> Table[TimeSelected] . SecPerUnit[DT_NEXT_UNIT] = LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE);
  805.  
  806.                                 MadeChanges = TRUE;
  807.  
  808.                                 break;
  809.  
  810.                             case GAD_LIST:
  811.  
  812.                                 LT_SetAttributes(Handle,GAD_TIME,
  813.                                     GTLV_Labels,~0,
  814.                                 TAG_DONE);
  815.  
  816.                                 if(TimeList)
  817.                                     FreeVecPooled(TimeList);
  818.  
  819.                                 TimeDateNode = (struct TimeDateNode *)GetListNode(MsgCode,(struct List *)&Entry -> TimeDateList);
  820.  
  821.                                 if(TimeList = BuildTimeList(TimeDateNode))
  822.                                 {
  823.                                     TimeSelected = 0;
  824.  
  825.                                     Selected = MsgCode;
  826.  
  827.                                     DisableGadgets(Handle,FALSE,FALSE,FALSE);
  828.  
  829.                                     TimeDateNode = (struct TimeDateNode *)GetListNode(Selected,(struct List *)&Entry -> TimeDateList);
  830.  
  831.                                     LT_SetAttributes(Handle,GAD_PAY1,
  832.                                         GTIN_Number,    TimeDateNode -> Table[TimeSelected] . PayPerUnit[DT_FIRST_UNIT],
  833.                                     TAG_DONE);
  834.  
  835.                                     LT_SetAttributes(Handle,GAD_MINUTES1,
  836.                                         GTIN_Number,    TimeDateNode -> Table[TimeSelected] . SecPerUnit[DT_FIRST_UNIT],
  837.                                     TAG_DONE);
  838.  
  839.                                     LT_SetAttributes(Handle,GAD_PAY2,
  840.                                         GTIN_Number,    TimeDateNode -> Table[TimeSelected] . PayPerUnit[DT_NEXT_UNIT],
  841.                                     TAG_DONE);
  842.  
  843.                                     LT_SetAttributes(Handle,GAD_MINUTES2,
  844.                                         GTIN_Number,    TimeDateNode -> Table[TimeSelected] . SecPerUnit[DT_NEXT_UNIT],
  845.                                     TAG_DONE);
  846.  
  847.                                     LT_SetAttributes(Handle,GAD_TIME,
  848.                                         GTLV_Labels,    TimeList,
  849.                                         GTLV_Selected,    0,
  850.                                         GA_Disabled,    FALSE,
  851.                                     TAG_DONE);
  852.  
  853.                                     LT_SetAttributes(Handle,GAD_ADDTIME,
  854.                                         GA_Disabled,    FALSE,
  855.                                     TAG_DONE);
  856.  
  857.                                     LT_SetAttributes(Handle,GAD_REMOVETIME,
  858.                                         GA_Disabled,    TimeDateNode -> Table[0] . Count < 2,
  859.                                     TAG_DONE);
  860.  
  861.                                     LT_SetAttributes(Handle,GAD_EDITTIME,
  862.                                         GA_Disabled,    FALSE,
  863.                                     TAG_DONE);
  864.  
  865.                                     if(Selected)
  866.                                     {
  867.                                         LT_SetAttributes(Handle,GAD_EDIT,
  868.                                             GA_Disabled,    FALSE,
  869.                                         TAG_DONE);
  870.  
  871.                                         LT_SetAttributes(Handle,GAD_CLONE,
  872.                                             GA_Disabled,    FALSE,
  873.                                         TAG_DONE);
  874.  
  875.                                         LT_SetAttributes(Handle,GAD_REMOVE,
  876.                                             GA_Disabled,    FALSE,
  877.                                         TAG_DONE);
  878.                                     }
  879.                                     else
  880.                                     {
  881.                                         LT_SetAttributes(Handle,GAD_EDIT,
  882.                                             GA_Disabled,    TRUE,
  883.                                         TAG_DONE);
  884.  
  885.                                         LT_SetAttributes(Handle,GAD_CLONE,
  886.                                             GA_Disabled,    TRUE,
  887.                                         TAG_DONE);
  888.  
  889.                                         LT_SetAttributes(Handle,GAD_REMOVE,
  890.                                             GA_Disabled,    TRUE,
  891.                                         TAG_DONE);
  892.                                     }
  893.                                 }
  894.                                 else
  895.                                 {
  896.                                     TimeDateNode = NULL;
  897.  
  898.                                     DisplayBeep(Window -> WScreen);
  899.  
  900.                                     LT_SetAttributes(Handle,GAD_LIST,
  901.                                         GTLV_Labels,    ~0,
  902.                                     TAG_DONE);
  903.  
  904.                                     DisableGadgets(Handle,TRUE,TRUE,TRUE);
  905.  
  906.                                     LT_SetAttributes(Handle,GAD_LIST,
  907.                                         GTLV_Labels,    &Entry -> TimeDateList,
  908.                                         GTLV_Selected,    ~0,
  909.                                     TAG_DONE);
  910.  
  911.                                     Selected = ~0;
  912.  
  913.                                     LT_SetAttributes(Handle,GAD_TIME,
  914.                                         GTLV_Labels,    &EmptyList,
  915.                                         GTLV_Selected,    ~0,
  916.                                         GA_Disabled,    TRUE,
  917.                                     TAG_DONE);
  918.  
  919.                                     TimeSelected = ~0;
  920.                                 }
  921.  
  922.                                 break;
  923.  
  924.                             case GAD_IMPORT:
  925.  
  926.                                 LT_LockWindow(Window);
  927.  
  928.                                 LT_SetAttributes(Handle,GAD_LIST,
  929.                                     GTLV_Labels,    ~0,
  930.                                 TAG_DONE);
  931.  
  932.                                 MadeChanges |= ImportPanel(Entry,PhoneList);
  933.  
  934.                                 DisableGadgets(Handle,TRUE,TRUE,TRUE);
  935.  
  936.                                 LT_SetAttributes(Handle,GAD_LIST,
  937.                                     GTLV_Labels,    &Entry -> TimeDateList,
  938.                                     GTLV_Selected,    ~0,
  939.                                 TAG_DONE);
  940.  
  941.                                 Selected = ~0;
  942.  
  943.                                 TimeSelected = ~0;
  944.  
  945.                                 LT_UnlockWindow(Window);
  946.  
  947.                                 LT_ShowWindow(Handle,TRUE);
  948.  
  949.                                 break;
  950.  
  951.                             case GAD_ADDDAY:
  952.                             case GAD_ADDDATE:
  953.  
  954.                                 LT_LockWindow(Window);
  955.  
  956.                                 MadeChanges = TRUE;
  957.  
  958.                                 if(NewNode = CreateTimeDateNode(0,1,"",2))
  959.                                 {
  960.                                     BYTE Result;
  961.  
  962.                                     if(MsgGadget -> GadgetID == GAD_ADDDAY)
  963.                                     {
  964.                                         NewNode -> Header . Month    = -1;
  965.                                         NewNode -> Header . Day        = 0;
  966.  
  967.                                         Result = DayPanel(NewNode);
  968.                                     }
  969.                                     else
  970.                                         Result = DatePanel(NewNode);
  971.  
  972.                                     if(Result)
  973.                                     {
  974.                                         AdaptTimeDateNode(NewNode);
  975.  
  976.                                         LT_SetAttributes(Handle,GAD_LIST,
  977.                                             GTLV_Labels,    ~0,
  978.                                         TAG_DONE);
  979.  
  980.                                         AddTail((struct List *)&Entry -> TimeDateList,&NewNode -> VanillaNode);
  981.  
  982.                                         Selected = Count++;
  983.  
  984.                                         LT_SetAttributes(Handle,GAD_LIST,
  985.                                             GTLV_Labels,        &Entry -> TimeDateList,
  986.                                             GTLV_Selected,        Selected,
  987.                                             GTLV_Top,        Selected,
  988.                                             GTLV_MakeVisible,    Selected,
  989.                                         TAG_DONE);
  990.  
  991.                                         TimeDateNode = NewNode;
  992.  
  993. Redisplay:                                    if(TimeList)
  994.                                             FreeVecPooled(TimeList);
  995.  
  996.                                         if(TimeList = BuildTimeList(TimeDateNode))
  997.                                         {
  998.                                             if(TimeSelected == ~0)
  999.                                                 TimeSelected = 0;
  1000.  
  1001.                                             DisableGadgets(Handle,FALSE,TRUE,FALSE);
  1002.  
  1003.                                             LT_SetAttributes(Handle,GAD_PAY1,
  1004.                                                 GTIN_Number,    TimeDateNode -> Table[TimeSelected] . PayPerUnit[DT_FIRST_UNIT],
  1005.                                             TAG_DONE);
  1006.  
  1007.                                             LT_SetAttributes(Handle,GAD_MINUTES1,
  1008.                                                 GTIN_Number,    TimeDateNode -> Table[TimeSelected] . SecPerUnit[DT_FIRST_UNIT],
  1009.                                             TAG_DONE);
  1010.  
  1011.                                             LT_SetAttributes(Handle,GAD_PAY2,
  1012.                                                 GTIN_Number,    TimeDateNode -> Table[TimeSelected] . PayPerUnit[DT_NEXT_UNIT],
  1013.                                             TAG_DONE);
  1014.  
  1015.                                             LT_SetAttributes(Handle,GAD_MINUTES2,
  1016.                                                 GTIN_Number,    TimeDateNode -> Table[TimeSelected] . SecPerUnit[DT_NEXT_UNIT],
  1017.                                             TAG_DONE);
  1018.  
  1019.                                             LT_SetAttributes(Handle,GAD_TIME,
  1020.                                                 GTLV_Labels,    TimeList,
  1021.                                                 GTLV_Selected,    TimeSelected,
  1022.                                                 GA_Disabled,    FALSE,
  1023.                                             TAG_DONE);
  1024.  
  1025.                                             LT_SetAttributes(Handle,GAD_ADDTIME,
  1026.                                                 GA_Disabled,    FALSE,
  1027.                                             TAG_DONE);
  1028.  
  1029.                                             LT_SetAttributes(Handle,GAD_REMOVETIME,
  1030.                                                 GA_Disabled,    TimeDateNode -> Table[0] . Count < 2,
  1031.                                             TAG_DONE);
  1032.  
  1033.                                             LT_SetAttributes(Handle,GAD_EDITTIME,
  1034.                                                 GA_Disabled,    FALSE,
  1035.                                             TAG_DONE);
  1036.  
  1037.                                             LT_Activate(Handle,GAD_PAY1);
  1038.                                         }
  1039.                                         else
  1040.                                         {
  1041.                                             TimeDateNode = NULL;
  1042.  
  1043.                                             DisplayBeep(Window -> WScreen);
  1044.  
  1045.                                             LT_SetAttributes(Handle,GAD_LIST,
  1046.                                                 GTLV_Labels,    ~0,
  1047.                                             TAG_DONE);
  1048.  
  1049.                                             DisableGadgets(Handle,TRUE,TRUE,TRUE);
  1050.  
  1051.                                             LT_SetAttributes(Handle,GAD_LIST,
  1052.                                                 GTLV_Labels,    &Entry -> TimeDateList,
  1053.                                                 GTLV_Selected,    ~0,
  1054.                                             TAG_DONE);
  1055.  
  1056.                                             Selected = ~0;
  1057.  
  1058.                                             LT_SetAttributes(Handle,GAD_TIME,
  1059.                                                 GA_Disabled,    FALSE,
  1060.                                                 GTLV_Selected,    0,
  1061.                                             TAG_DONE);
  1062.  
  1063.                                             TimeSelected = ~0;
  1064.                                         }
  1065.                                     }
  1066.                                     else
  1067.                                         FreeVecPooled(NewNode);
  1068.                                 }
  1069.  
  1070.                                 LT_UnlockWindow(Window);
  1071.  
  1072.                                 LT_ShowWindow(Handle,TRUE);
  1073.  
  1074.                                 break;
  1075.  
  1076.                             case GAD_REMOVE:
  1077.  
  1078.                                 if(--Count)
  1079.                                 {
  1080.                                     if(TimeDateNode -> VanillaNode . ln_Succ -> ln_Succ)
  1081.                                         NewNode = (struct TimeDateNode *)TimeDateNode -> VanillaNode . ln_Succ;
  1082.                                     else
  1083.                                         NewNode = (struct TimeDateNode *)TimeDateNode -> VanillaNode . ln_Pred;
  1084.                                 }
  1085.  
  1086.                                 MadeChanges = TRUE;
  1087.  
  1088.                                 LT_SetAttributes(Handle,GAD_LIST,
  1089.                                     GTLV_Labels,    ~0,
  1090.                                 TAG_DONE);
  1091.  
  1092.                                 Remove(TimeDateNode);
  1093.  
  1094.                                 FreeVecPooled(TimeDateNode);
  1095.  
  1096.                                 if(Count > 1)
  1097.                                 {
  1098.                                     LT_SetAttributes(Handle,GAD_LIST,
  1099.                                         GTLV_Labels,    &Entry -> TimeDateList,
  1100.                                         GTLV_Selected,    Count,
  1101.                                     TAG_DONE);
  1102.  
  1103.                                     TimeDateNode = NewNode;
  1104.  
  1105.                                     goto Redisplay;
  1106.                                 }
  1107.                                 else
  1108.                                 {
  1109.                                     DisableGadgets(Handle,TRUE,TRUE,FALSE);
  1110.  
  1111.                                     LT_SetAttributes(Handle,GAD_LIST,
  1112.                                         GTLV_Labels,    &Entry -> TimeDateList,
  1113.                                         GTLV_Selected,    ~0,
  1114.                                     TAG_DONE);
  1115.  
  1116.                                     TimeDateNode = NULL;
  1117.                                 }
  1118.  
  1119.                                 break;
  1120.  
  1121.                             case GAD_CLONE:
  1122.  
  1123.                                 if(NewNode = CreateTimeDateNode(0,1,"",TimeDateNode -> Table[0] . Count))
  1124.                                 {
  1125.                                     MadeChanges = TRUE;
  1126.  
  1127.                                     CopyMem(TimeDateNode,NewNode,sizeof(struct TimeDateNode));
  1128.  
  1129.                                     NewNode -> VanillaNode . ln_Name = NewNode -> Buffer;
  1130.  
  1131.                                     LT_SetAttributes(Handle,GAD_LIST,
  1132.                                         GTLV_Labels,    ~0,
  1133.                                     TAG_DONE);
  1134.  
  1135.                                     AddTail((struct List *)&Entry -> TimeDateList,&NewNode -> VanillaNode);
  1136.  
  1137.                                     LT_SetAttributes(Handle,GAD_LIST,
  1138.                                         GTLV_Labels,    &Entry -> TimeDateList,
  1139.                                         GTLV_Selected,    Count++,
  1140.                                     TAG_DONE);
  1141.  
  1142.                                     TimeDateNode = NewNode;
  1143.  
  1144.                                     goto Redisplay;
  1145.                                 }
  1146.  
  1147.                                 break;
  1148.  
  1149.                             case GAD_EDIT:
  1150.  
  1151.                                 LT_LockWindow(Window);
  1152.  
  1153.                                 LT_SetAttributes(Handle,GAD_LIST,
  1154.                                     GTLV_Labels,    ~0,
  1155.                                 TAG_DONE);
  1156.  
  1157.                                 if(TimeDateNode -> Header . Month == -1)
  1158.                                     MadeChanges |= DayPanel(TimeDateNode);
  1159.                                 else
  1160.                                     MadeChanges |= DatePanel(TimeDateNode);
  1161.  
  1162.                                 AdaptTimeDateNode(TimeDateNode);
  1163.  
  1164.                                 LT_SetAttributes(Handle,GAD_LIST,
  1165.                                     GTLV_Labels,    &Entry -> TimeDateList,
  1166.                                     GTLV_Selected,    Selected,
  1167.                                 TAG_DONE);
  1168.  
  1169.                                 LT_UnlockWindow(Window);
  1170.  
  1171.                                 LT_ShowWindow(Handle,TRUE);
  1172.  
  1173.                                 break;
  1174.                         }
  1175.                     }
  1176.  
  1177.                     if(MsgClass == IDCMP_IDCMPUPDATE)
  1178.                     {
  1179.                         switch(MsgGadget -> GadgetID)
  1180.                         {
  1181.                             case GAD_TIME:
  1182.  
  1183.                                 if(Selected != ~0 && TimeSelected != ~0)
  1184.                                 {
  1185.                                     UBYTE Time = TimeDateNode -> Table[TimeSelected] . Time;
  1186.  
  1187.                                     LT_PressButton(Handle,GAD_EDITTIME);
  1188.  
  1189.                                     LT_LockWindow(Window);
  1190.  
  1191.                                     if(TimePanel(&TimeDateNode -> Table[TimeSelected] . Time))
  1192.                                     {
  1193.                                         struct List *NewTimeList;
  1194.  
  1195.                                         MadeChanges = TRUE;
  1196.  
  1197.                                         SortTimeTable(TimeDateNode);
  1198.  
  1199.                                         if(NewTimeList = BuildTimeList(TimeDateNode))
  1200.                                         {
  1201.                                             LT_SetAttributes(Handle,GAD_TIME,
  1202.                                                 GTLV_Labels,    ~0,
  1203.                                             TAG_DONE);
  1204.  
  1205.                                             if(TimeList)
  1206.                                                 FreeVecPooled(TimeList);
  1207.  
  1208.                                             TimeList = NewTimeList;
  1209.  
  1210.                                             LT_SetAttributes(Handle,GAD_TIME,
  1211.                                                 GTLV_Labels,    TimeList,
  1212.                                                 GTLV_Selected,    0,
  1213.                                                 GA_Disabled,    FALSE,
  1214.                                             TAG_DONE);
  1215.  
  1216.                                             LT_SetAttributes(Handle,GAD_LIST,
  1217.                                                 GTLV_Labels,    ~0,
  1218.                                             TAG_DONE);
  1219.  
  1220.                                             DisableGadgets(Handle,TRUE,TRUE,TRUE);
  1221.  
  1222.                                             LT_SetAttributes(Handle,GAD_LIST,
  1223.                                                 GTLV_Labels,    &Entry -> TimeDateList,
  1224.                                                 GTLV_Selected,    ~0,
  1225.                                             TAG_DONE);
  1226.  
  1227.                                             Selected = ~0;
  1228.  
  1229.                                             TimeSelected = ~0;
  1230.                                         }
  1231.                                         else
  1232.                                         {
  1233.                                             TimeDateNode -> Table[TimeSelected] . Time = Time;
  1234.  
  1235.                                             SortTimeTable(TimeDateNode);
  1236.  
  1237.                                             DisplayBeep(Window -> WScreen);
  1238.                                         }
  1239.                                     }
  1240.  
  1241.                                     LT_UnlockWindow(Window);
  1242.  
  1243.                                     LT_ShowWindow(Handle,TRUE);
  1244.                                 }
  1245.  
  1246.                                 break;
  1247.  
  1248.                             case GAD_LIST:
  1249.  
  1250.                                 if(Selected != ~0 && Selected > 0)
  1251.                                 {
  1252.                                     LT_PressButton(Handle,GAD_EDIT);
  1253.  
  1254.                                     LT_LockWindow(Window);
  1255.     
  1256.                                     LT_SetAttributes(Handle,GAD_LIST,
  1257.                                         GTLV_Labels,    ~0,
  1258.                                     TAG_DONE);
  1259.     
  1260.                                     if(TimeDateNode -> Header . Month == -1)
  1261.                                         MadeChanges |= DayPanel(TimeDateNode);
  1262.                                     else
  1263.                                         MadeChanges |= DatePanel(TimeDateNode);
  1264.     
  1265.                                     AdaptTimeDateNode(TimeDateNode);
  1266.     
  1267.                                     LT_SetAttributes(Handle,GAD_LIST,
  1268.                                         GTLV_Labels,    &Entry -> TimeDateList,
  1269.                                         GTLV_Selected,    Selected,
  1270.                                     TAG_DONE);
  1271.     
  1272.                                     LT_UnlockWindow(Window);
  1273.     
  1274.                                     LT_ShowWindow(Handle,TRUE);
  1275.     
  1276.                                     break;
  1277.                                 }
  1278.  
  1279.                                 break;
  1280.                         }
  1281.                     }
  1282.                 }
  1283.             }
  1284.             while(!Done);
  1285.  
  1286.             PopWindow();
  1287.  
  1288.             if(TimeList)
  1289.                 FreeVecPooled(TimeList);
  1290.         }
  1291.  
  1292.         LT_DeleteHandle(Handle);
  1293.     }
  1294.  
  1295.     return(MadeChanges);
  1296. }
  1297.